Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@core/internal/llmtests/account.go`:
- Around line 44-45: AllProviderConfigs' Vertex provider config is missing the
multimodal embedding flags so tests skip that scenario; update the Vertex entry
in AllProviderConfigs to set Scenarios.MultimodalEmbedding = true and set
MultimodalEmbeddingModel = "multimodalembedding@001" (and any corresponding
field assignment on the Vertex provider config struct) so the Scenarios and
model whitelist match the API key whitelist referenced earlier; locate the
Vertex provider config near the AllProviderConfigs variable and add those fields
to the config and its Scenarios struct assignment.

In `@core/internal/llmtests/embedding_multimodal.go`:
- Around line 47-86: validateNonEmptyVectors misses the case where a provider
returns a collapsed batch (one resp.Data entry with Embedding.Embedding2DArray);
update validateNonEmptyVectors to normalize that shape before iterating: if
len(resp.Data) == 1 and resp.Data[0].Embedding.Embedding2DArray != nil, treat
each row in Embedding2DArray as its own embedding entry (either by expanding
into a temporary slice of items or by iterating the 2D array directly), then use
getEmbeddingVector (or a small helper that extracts the vector from the 2D array
rows) to validate non-empty vectors and consistent dimensions for every expanded
embedding; also update the final t.Logf to report the expanded embedding count
instead of len(resp.Data).

In `@core/providers/bedrock/embedding.go`:
- Around line 11-13: The conversion function ToBedrockTitanEmbeddingRequest is
incorrectly collapsing the batch dimension by concatenating all Contents into a
single InputText; instead add a guard that asserts or returns an error if the
incoming request contains more than one content item (i.e., len(req.Contents) !=
1) so we only accept single-content requests here, and remove the logic that
stitches multiple Contents together (the code that builds a single InputText
from all parts); this ensures the core layer must fan out and prevents silently
returning one embedding for a multi-item request.

In `@core/providers/cohere/embedding.go`:
- Around line 195-200: The conversion currently silently drops extra images when
handling req.Images (case len(req.Images) > 0) and builds
bifrostReq.Input.Contents with only req.Images[0]; add explicit validation to
reject multiple images by checking if len(req.Images) > 1 and returning an error
(or propagate an appropriate conversion error) before constructing
bifrostReq.Input.Contents; reference the existing symbols req.Images,
bifrostReq.Input.Contents, EmbeddingContentPartTypeImage and EmbeddingMediaPart
when locating the change in core/providers/cohere/embedding.go.

In `@core/providers/gemini/embedding.go`:
- Around line 173-176: The current check conflates an empty contents slice with
an actual error and wraps a nil error (from EmbeddingInputToContents) causing
the %!w(<nil>) output; change the logic in embedding.go after calling
EmbeddingInputToContents to first handle err != nil and return fmt.Errorf("error
converting embedding input to contents: %w", err), and if err == nil but
len(contents) == 0 return a distinct non-wrapping error (e.g.,
fmt.Errorf("embedding input produced no contents")) so the message is clear when
contents is empty.

In `@core/providers/openai/embedding.go`:
- Around line 67-100: The converter currently flattens all parts across
bifrostReq.Input.Contents into global texts/tokenBatches, losing
per-EmbeddingContent boundaries; change the logic to iterate each content (each
entry in bifrostReq.Input.Contents) and build one OpenAIEmbeddingInput per
content: for each content, ensure parts are all the same type (error if mixed),
for text parts concatenate their strings into a single Text (e.g., join with a
space) and set OpenAIEmbeddingInput.Text, and for token parts concatenate token
slices into a single Embedding and set OpenAIEmbeddingInput.Embedding; finally
produce one input per content (a slice of OpenAIEmbeddingInput) instead of
flattening across contents so that each EmbeddingContent maps to one OpenAI
result (update code around bifrostReq.Input.Contents, OpenAIEmbeddingInput, and
the switch that currently sets Texts/Texts/Embeddings).

In `@core/providers/vertex/embedding.go`:
- Around line 149-152: Remove the stray debug print by deleting the
fmt.Println("b64", b64) call in core/providers/vertex/embedding.go; keep the
logic that calls extractBase64FromDataURI(*part.Image.Data) and assigns the
result to img.BytesBase64Encoded (variable b64), and ensure no other fmt.Println
debug statements remain in the same function or nearby code that handles
part.Image.Data or img.BytesBase64Encoded.

In `@core/providers/vertex/vertex.go`:
- Around line 1395-1402: The Embedding() method currently always fetches OAuth
credentials instead of supporting API-key auth like ChatStream() and
GenerateContent(); update Embedding() to first check key.Value.GetValue() and,
if non-empty, build authQuery and append it to the Gemini URL (use
getCompleteURLForGeminiEndpoint with ":embedContent" for
isGeminiEmbedding2Request) before making the request, otherwise fall back to the
existing OAuth flow (the same logic used in ChatStream()/GenerateContent());
ensure authQuery is used consistently when constructing the request URL so
VERTEX_API_KEY-only setups succeed.

In `@core/schemas/trace.go`:
- Line 219: The AttrDimensions constant was changed and that is a
telemetry-breaking change; revert AttrDimensions back to the existing legacy key
("gen_ai.embeddings.dimension.count") and introduce a new constant (e.g.,
AttrDimensionsV2 or AttrEmbeddingDimensionsKey) with the new wire key for
dual-writing during migration; update any writers to emit both constants where
needed but keep AttrDimensions unchanged to preserve
dashboards/filters/exporters that rely on it.

In `@plugins/logging/utils.go`:
- Around line 422-431: The loop building contentBlocks for logging currently
only appends parts where part.Type == schemas.EmbeddingContentPartTypeText,
dropping image/audio/video/file parts and producing empty user messages; update
the logic in the block that iterates request.EmbeddingRequest.Input.Contents to
also handle non-text parts by appending a schemas.ChatContentBlock for each
non-text part (e.g., set Type to a suitable value or to
schemas.ChatContentBlockTypeText with a Text placeholder) that records the
part.Type and any available metadata (filename, mime, size, description, or a
generated placeholder like "[image]" / "[audio]" / "[file]"). Ensure the new
branch references request.EmbeddingRequest.Input.Contents, contentBlocks,
part.Type, and schemas.ChatContentBlock so multimodal embedding inputs are
preserved in the log history.

In `@plugins/semanticcache/utils.go`:
- Around line 447-456: extractTextForEmbedding currently returns an empty string
for embedding requests that contain only non-text parts, which leads
generateEmbeddingsForStorage and performSemanticSearch to call
generateEmbedding("") and produce identical cache keys; update
extractTextForEmbedding to mirror Chat/Responses behavior by checking
len(textParts) > 0 and return a sentinel/error (or a boolean indicating "no
text") instead of an empty string, and update callers
(generateEmbeddingsForStorage and performSemanticSearch) to skip semantic
caching / embedding generation when that sentinel/no-text is returned so
multimodal-only embedding requests do not collide in the semantic cache.

In `@tests/integrations/python/tests/test_cohere.py`:
- Around line 159-196: Both tests request Cohere-only embedding features and
must skip when provider/model lacks those capabilities: update
test_06_custom_dimensions_embedding and test_07_multiple_embedding_types to
check supports_capability(provider, model, "<capability>") (from config_loader)
before running; for test_06 check capability for "embeddings_custom_dimensions"
or the equivalent capability used elsewhere (or guard specifically for
Cohere/embed-v4.0), and for test_07 check capability for "embeddings_int8" (or
guard for Cohere), calling pytest.skip(...) if unsupported — mirror the
capability-guard pattern used in test_pydanticai.py and use
get_provider_cohere_client/format_provider_model as before.

In `@tests/integrations/python/tests/test_google.py`:
- Around line 3091-3106: The test 'test_45' is inconsistent: the docstring says
"a text part" but the request builds contents with two identical text parts
using types.Content(parts=[types.Part(text=...), types.Part(text=...),
types.Part.from_bytes(...)]). Fix by either updating the docstring to say "two
text parts" or change the second types.Part(text=...) to a distinct text string
that reflects the intended test scenario so the intent and payload match.

---

Outside diff comments:
In `@core/bifrost.go`:
- Around line 911-940: The empty-Contents guard in the embedding request path
rejects legacy callers because legacy fields (req.Input.Text, req.Input.Texts,
req.Input.Embedding, req.Input.Embeddings) are not normalized to
req.Input.Contents before the check; move or call the compatibility
normalization that populates req.Input.Contents for legacy fields before the if
that checks (req.Input == nil || len(req.Input.Contents) == 0) and
isLargePayloadPassthrough(ctx), or alternatively change that guard to also
accept legacy-field presence and run the normalization immediately prior to
calling req.Input.Validate(); ensure Validate() continues to run against the
normalized Contents so legacy callers remain supported.

---

Nitpick comments:
In `@core/internal/llmtests/embedding.go`:
- Around line 61-65: Replace local-address pointer creation in the test payload
by using bifrost.Ptr to match repo conventions: in the loop that builds contents
(variable contents of type []schemas.EmbeddingContent) switch from creating a
local t and taking &t to using bifrost.Ptr(text) for the Text field (the place
where schemas.EmbeddingContent and schemas.EmbeddingContentPartTypeText are
set). Ensure bifrost is imported if not already.

In `@core/providers/cohere/embedding_multimodal_test.go`:
- Around line 11-16: Replace direct address-of pointer usage for the
EmbeddingInput.Text field with the existing pointer helper used elsewhere in the
test: instead of &text use schemas.Ptr(text) (or bifrost.Ptr if that helper is
in scope) when constructing the EmbeddingContent in ToCohereEmbeddingRequest/
schemas.BifrostEmbeddingRequest; update the other occurrences noted (around
lines 25-30) so all pointer construction in this fixture is done via the same
Ptr helper for consistency.

In `@core/providers/cohere/embedding.go`:
- Around line 117-127: The conversion loop silently returns nil on errors from
cohereContentBlockFromEmbeddingPart, losing context; update the surrounding
function (the routine building CohereEmbeddingInput and setting
cohereReq.Inputs) to propagate errors instead of returning nil: change the
function signature to return (..., error) if needed, capture the error from
cohereContentBlockFromEmbeddingPart and return it (or wrap it with context)
rather than returning nil, and ensure both occurrences (the loop at the first
branch and the similar block at line ~135) follow the same error propagation so
callers can log or handle the specific conversion error.

In `@core/providers/gemini/embedding.go`:
- Around line 140-163: The function applyGeminiEmbeddingParams currently reads
boolean values from params.ExtraParams with schemas.SafeExtractBoolPointer,
assigns them back into req.ExtraParams and then immediately deletes them — the
nil checks and deletes are redundant and the code does not promote these values
to top-level fields; fix by either (A) removing this whole extraction/delete
block if these flags should remain only in ExtraParams, or (B) if you intend to
promote them, add top-level bool fields on the request (e.g., DocumentOCR and
AudioTrackExtraction on GeminiEmbeddingRequest), set req.DocumentOCR and
req.AudioTrackExtraction from the extracted pointers, and then delete those keys
from req.ExtraParams; update applyGeminiEmbeddingParams to use
params.ExtraParams -> SafeExtractBoolPointer -> set top-level req fields ->
delete keys from req.ExtraParams (no redundant nil checks).
- Around line 409-421: The code silently returns nil when
geminiContentToEmbeddingContent fails, losing error context; update the function
that builds bifrostReq (the block handling request.Requests and uses
geminiContentToEmbeddingContent, bifrostReq, and applyBifrostEmbeddingParams) to
propagate the conversion error instead of returning nil—i.e., change the return
path to return (nil, err) or wrap and return a descriptive error so callers can
distinguish conversion failures, and if the function signature cannot change, at
minimum log the error with context (including which req failed) before
returning; ensure all callsites of this function are updated to handle the
propagated error when you adjust the signature.

In `@core/providers/gemini/types.go`:
- Around line 1135-1137: The DocumentOCR and AudioTrackExtraction fields only
accept camelCase JSON keys and will miss snake_case keys; update the struct that
defines DocumentOCR and AudioTrackExtraction in core/providers/gemini/types.go
to accept both wire casings by implementing a custom UnmarshalJSON for that
struct: parse into a secondary map[string]json.RawMessage (or a small alias
struct), check for both "documentOcr" and "document_ocr" (and
"audioTrackExtraction" and "audio_track_extraction"), and set the DocumentOCR
and AudioTrackExtraction boolean pointers accordingly, preserving existing
behavior for other fields.

In `@core/providers/vertex/embedding.go`:
- Around line 96-109: The code redundantly reads boolean pointers from
params.ExtraParams and writes them back to req.ExtraParams then deletes keys
from the same map, causing no net effect; update the block around
schemas.SafeExtractBoolPointer so you either (A) simply copy values from
params.ExtraParams into req.ExtraParams without deleting, or (B) if the intent
is to move keys, ensure you delete from params.ExtraParams (not req.ExtraParams)
and only perform the delete when params.ExtraParams and req.ExtraParams are
different maps; adjust the handling for the keys "documentOcr" and
"audioTrackExtraction" accordingly.

In `@core/schemas/embedding_multimodal_test.go`:
- Around line 9-27: Add a happy-path validation test for both a text embedding
and a media embedding: create a TestEmbeddingInputValidateAcceptsNonEmpty that
constructs an EmbeddingInput with a non-empty Contents containing a single
EmbeddingContentPart of Type EmbeddingContentPartTypeText with Text set and
assert Validate() returns no error; and create a
TestEmbeddingContentPartValidateAcceptsSingleMedia that constructs an
EmbeddingContentPart of Type EmbeddingContentPartTypeImage with Image set to an
EmbeddingMediaPart (use Ptr("https://example.com/img.png") or the existing
helper) and assert part.Validate() returns nil; reference
EmbeddingInput.Validate, EmbeddingContentPart.Validate,
EmbeddingContentPartTypeImage/Text, and EmbeddingMediaPart to locate code.

In `@plugins/semanticcache/test_utils.go`:
- Around line 557-560: The loop in the test helper creates a loop-local copy (t
:= text) and takes its address for EmbeddingContent.Text; replace that pattern
with bifrost.Ptr(text) (i.e., set Text: bifrost.Ptr(text)) to follow the repo
convention and remove the temporary variable; update the assignment in the loop
that populates contents (and ensure the bifrost package is imported if not
already) so schemas.EmbeddingContent uses bifrost.Ptr instead of &t.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@core/internal/llmtests/utils.go`:
- Around line 627-669: getEmbeddingVector currently ignores bit-packed
embeddings (Binary / Ubinary) and returns "no valid embedding data found";
update getEmbeddingVector to detect and handle e.Binary and e.Ubinary similarly
to the base64 path: if either is present, treat the byte slice as little-endian
float32-packed data, verify length%4==0, iterate 4-byte chunks with
binary.LittleEndian.Uint32 and math.Float32frombits to populate and return a
[]float64, and include the same error handling as the base64 branch for bad
lengths; reference the function name getEmbeddingVector and the embedding fields
e.Binary and e.Ubinary when making the change.

In `@core/providers/cohere/embedding.go`:
- Around line 90-95: The converter is aliasing bifrostReq.Params.ExtraParams
into cohereReq.ExtraParams and then mutating it, causing side effects; instead,
when Params.ExtraParams is non-nil create a new map, copy each key/value into it
(e.g., make(map[string]interface{}, len(...)) and loop to assign), set
cohereReq.ExtraParams to that clone, and only mutate the clone; apply the same
cloning approach wherever the converters copy ExtraParams (the other converter
blocks referenced around the later ranges) so conversion functions remain pure
and do not modify the caller's map.
- Around line 334-367: cohereResp.Embeddings is never initialized and
hasFloat/hasBase64 are never set, causing a panic on the first append and
incorrect final assignment; fix by initializing cohereResp.Embeddings (or
embeddingData) before any appends, set hasFloat = true when encountering
emb.Float and hasBase64 = true when encountering emb.Base64 while iterating
bifrostResp.Data, append into the initialized embedding struct (e.g.,
embeddingData.Float, embeddingData.Base64, etc.), and after the loop assign
cohereResp.Embeddings = embeddingData only if hasFloat || hasBase64 (otherwise
leave nil or set appropriate type marker). Ensure you reference
CohereEmbeddingResponse, embeddingData, hasFloat, hasBase64 and the loop over
bifrostResp.Data when making the change.

In `@core/providers/gemini/embedding.go`:
- Around line 136-146: The code mutates the caller's params.ExtraParams map by
assigning it to req.ExtraParams and then deleting keys; fix this in the
embedding conversion by making a shallow copy of params.ExtraParams (handle nil)
and assign that copy to req.ExtraParams, then run schemas.SafeExtractBoolPointer
on the copied map for "documentOcr" and "audioTrackExtraction" and delete those
keys from the copy instead of the original; keep using the same helper
schemas.SafeExtractBoolPointer and set req.DocumentOCR and
req.AudioTrackExtraction accordingly.

In `@core/providers/huggingface/embedding.go`:
- Around line 98-111: The extractTextFromContent function currently concatenates
text parts without separators, collapsing boundaries (e.g., ["foo","bar"] ->
"foobar"); update extractTextFromContent to insert a delimiter (e.g., a single
space or newline) between parts when appending to the strings.Builder so each
part boundary is preserved while keeping the existing validation (check
part.Type == schemas.EmbeddingContentPartTypeText and part.Text != nil) and the
empty-content error; modify the loop in extractTextFromContent to write the
delimiter only when sb.Len() > 0 before appending the next *part.Text.

In `@core/providers/openai/types.go`:
- Around line 53-58: The OpenAIEmbeddingInput flattening causes multiple input
parts from a single schemas.EmbeddingContent to be sent as separate upstream
inputs; update ToOpenAIEmbeddingRequest to preserve one EmbeddingContent per
OpenAI input by aggregating parts of each schemas.EmbeddingContent before
populating OpenAIEmbeddingInput.Texts and .Embeddings (and any tokenBatches
logic) so each element of request.Input.Contents maps to exactly one
OpenAIEmbeddingInput entry; locate and change the logic in
ToOpenAIEmbeddingRequest (core/providers/openai/embedding.go) that iterates
request.Input.Contents and currently appends parts into single slices to instead
combine/concat parts per content and push one OpenAIEmbeddingInput per content,
ensuring fields Text, Texts, Embedding, or Embeddings are set appropriately for
that aggregated content.

In `@core/providers/vertex/embedding.go`:
- Around line 95-105: The code mutates the input map by assigning
params.ExtraParams to req.ExtraParams and then deleting keys; change this to
create a shallow copy of params.ExtraParams and assign the copy to
req.ExtraParams, then perform the SafeExtractBoolPointer checks (for
"documentOcr" and "audioTrackExtraction") and delete those keys from the copied
map while setting req.DocumentOCR and req.AudioTrackExtraction; reference the
symbols params.ExtraParams, req.ExtraParams, schemas.SafeExtractBoolPointer,
req.DocumentOCR, and req.AudioTrackExtraction to locate and update the logic so
the original params.ExtraParams remains unmodified.

In `@framework/logstore/migrations.go`:
- Around line 2413-2453: The migration only reads input_history[0], dropping
subsequent legacy inputs; update the SQL in migrations.go (the UPDATE that sets
embedding_input for object_type='embedding') to iterate over all entries in
input_history instead of hard-coding the first element: for Postgres, replace
(input_history::jsonb -> 0 -> 'content' -> 'content_blocks') with a full
expansion like jsonb_array_elements(input_history::jsonb) -> 'content' ->
'content_blocks' (or nested jsonb_array_elements twice) so you aggregate text
blocks from every history item before jsonb_agg into embedding_input; for
SQLite, change json_extract(input_history, '$[0].content.content_blocks') and
its json_each to iterate over all array entries (e.g., json_each(input_history)
then json_each(json_extract(..., '$.content.content_blocks')) ) so
json_group_array collects blocks from every history entry while keeping the
existing filters and embedding_input/null checks. Ensure the aggregate still
builds objects with type='text' and non-empty text fields.

In `@plugins/logging/main.go`:
- Around line 207-208: The EmbeddingInput field currently stores full
schemas.EmbeddingContent (including Image/Audio/File/Video.Data) which can
contain large/base64 or sensitive blobs; before assigning to EmbeddingInput, run
the same truncation/redaction utility used for transcription and image inputs
(the threshold-based redactor used elsewhere) to strip or truncate raw Data
fields and large payloads, and assign the sanitized result to EmbeddingInput;
update all assignment sites including the other occurrences noted around the
block at lines 480-483 to use the redaction helper so logs never receive full
binary/base64 content.

In `@tests/integrations/python/tests/test_cohere.py`:
- Line 50: The parameter annotation for assert_valid_cohere_embedding_response
uses an implicit optional (expected_dimensions: int = None); change it to an
explicit optional type (expected_dimensions: int | None = None or
expected_dimensions: Optional[int] = None) and, if using Optional, add the
necessary typing import; update the function signature and any related type
hints accordingly.

In `@ui/app/workspace/logs/sheets/logDetailView.tsx`:
- Around line 1016-1022: The current branch (inside the isEmbedding case)
flattens log.embedding_input into a texts array and drops non-text parts;
instead, preserve full EmbeddingContent semantics by assigning the original
embedding_input structure to requestBody.input when log.embedding_input exists
(i.e., requestBody.input = log.embedding_input) so each EmbeddingContent maps to
one output embedding; keep the existing text-only extraction and fallback only
when embedding_input is absent or empty (use the map/filter/flat logic only for
older logs that lack embedding_input) and ensure any type expectations for
requestBody.input are respected when switching to the full embedding_input
structure.

---

Outside diff comments:
In `@core/internal/llmtests/response_validation.go`:
- Around line 1324-1348: The presence check currently accepts
embedding.Embedding.Base64 as valid data but the dimensions-check logic
(iterating response.Data and computing actualDimensions from e.Float, e.Int8,
e.Uint8, e.Binary, e.Ubinary) never handles Base64, causing Base64-only
embeddings to report dimension 0 and fail expected_dimensions; update the
dimension path to detect e.Base64, decode the base64 payload to raw bytes and
set actualDimensions = len(decodedBytes) (using standard base64 decode), and
update any other dimension/metrics computation that reads actualDimensions (the
loop over response.Data and the metrics block that computes embedding
dimensions) to use the decoded length so Base64-only embeddings are validated
correctly; alternatively, if you prefer not to decode here, remove Base64 from
the initial hasData check in the embedding presence check
(embedding.Embedding.Base64) so Base64-only embeddings are not treated as having
data.

In `@core/providers/gemini/types.go`:
- Around line 1255-1279: The outer aliasing in PartAlias doesn't handle
snake_case keys nested inside file_data because FileData's struct tags are
camelCase-only; implement a custom UnmarshalJSON on the FileData type that
defines an internal alias with both camelCase and snake_case json tags (e.g.,
DisplayName/display_name, FileURI/file_uri, MIMEType/mime_type), unmarshal into
that aux, and then populate FileData's fields by preferring the camelCase values
and falling back to the snake_case values when empty so that p.FileData (and any
code using FileData) receives the actual nested values.

In `@core/providers/vertex/vertex.go`:
- Around line 1520-1548: The Vertex embedding branch skips the common raw
request/response capture so bifrostResponse.ExtraFields.RawRequest isn't
populated when provider.sendBackRawRequest is enabled; restore that capture
before converting to BifrostEmbeddingResponse by invoking the same handling used
elsewhere (e.g., call providerUtils.HandleProviderResponse or otherwise
unmarshal jsonBody into a map and set bifrostResponse.ExtraFields.RawRequest) in
both branches (the gemini.GeminiEmbeddingResponse path and the
VertexEmbeddingResponse path) using the existing flags
provider.sendBackRawRequest/provider.sendBackRawResponse and functions
providerUtils.ShouldSendBackRawResponse and providerUtils.EnrichError to keep
error handling consistent. Ensure the RawRequest is set prior to assigning
bifrostResponse.Model/ExtraFields so the typed unmarshalling
(VertexEmbeddingResponse.ToBifrostEmbeddingResponse /
gemini.ToBifrostEmbeddingResponse) remains unchanged.

In `@ui/app/workspace/logs/sheets/logDetailView.tsx`:
- Around line 952-953: The isEmbedding discriminator currently checks log.object
=== "list" but the render path uses "embedding", so update the condition in
logDetailView.tsx (the isEmbedding variable) to match the render path (e.g.,
check log.object === "embedding" or accept both "embedding" and "list" if
backward compatibility is needed) so the "Copy request body" flow enters the
embedding branch; locate and update the isEmbedding declaration and any
dependent branches that gate the embedding copy behavior to use the corrected
discriminator.

---

Duplicate comments:
In `@core/providers/bedrock/embedding.go`:
- Around line 12-40: The converter ToBedrockTitanEmbeddingRequest currently
concatenates all entries in bifrostReq.Input.Contents into one
BedrockTitanEmbeddingRequest.InputText, collapsing the batch dimension; change
it to require exactly one content item (error if len(bifrostReq.Input.Contents)
!= 1) and only iterate over that single content's parts to build InputText,
preserving the 1:1 request/response shape; keep the existing validation for part
types (schemas.EmbeddingContentPartTypeText) and the
BedrockTitanEmbeddingRequest construction unchanged.

In `@core/providers/cohere/embedding.go`:
- Around line 195-200: The code in embedding.go silently drops additional images
by only converting req.Images[0]; update the handler that checks req.Images (the
case starting with "case len(req.Images) > 0") to explicitly reject requests
where len(req.Images) > 1 by returning an error (or appropriate response)
instead of proceeding, and keep the existing behavior for exactly one image by
populating bifrostReq.Input.Contents with a single schemas.EmbeddingContent
entry using schemas.EmbeddingContentPartTypeImage and
schemas.EmbeddingMediaPart{URL: &url}; ensure the error message clearly states
that multiple images are unsupported and references req.Images so callers
understand the validation.

In `@plugins/semanticcache/utils.go`:
- Around line 450-459: After collecting textParts from
req.EmbeddingRequest.Input.Contents (the loop that checks part.Type ==
schemas.EmbeddingContentPartTypeText), detect when len(textParts) == 0 and fail
fast instead of returning an empty string: return a sentinel error (e.g.,
ErrNoTextParts) or the existing "skip cache" sentinel used by chat/responses,
along with metadataHash, so callers can bypass semantic caching; if
ErrNoTextParts doesn't exist, add it as a package-level var and use it here.

In `@tests/integrations/python/tests/test_cohere.py`:
- Around line 159-196: Both tests (test_06_custom_dimensions_embedding and
test_07_multiple_embedding_types) run for all providers but rely on Cohere-only
features; add capability checks and skip when the current provider/model doesn't
support them. Use the existing test helpers (e.g., get_provider_cohere_client,
format_provider_model, get_cross_provider_params_for_scenario) to query provider
capabilities and gate: in test_06 check for a capability like support for
output_dimension/custom_dimensions (or a provider capability flag for 512-d
embeddings) and call pytest.skip if missing; in test_07 check for support of
multiple embedding types / int8 embeddings and skip if not present. Ensure the
checks run before creating the client so unsupported providers are skipped
rather than failing.

---

Nitpick comments:
In `@core/providers/fireworks/fireworks_test.go`:
- Around line 191-193: The test currently takes the address of a temporary
string (variable text) when constructing the Contents slice of
schemas.EmbeddingContent; replace that pattern by using the repository pointer
helper bifrost.Ptr to create the *string instead. Update the EmbeddingContent
construction (the Contents: []schemas.EmbeddingContent{...} entry where Type is
schemas.EmbeddingContentPartTypeText) to call bifrost.Ptr(yourText) rather than
&text so the pointer creation is consistent with other tests and utilities.

In `@core/providers/gemini/embedding.go`:
- Around line 386-394: The conversion loop using geminiContentToEmbeddingContent
silently swallows errors by returning nil; update the converter to propagate or
log conversion failures: modify the surrounding function that builds bifrostReq
(reference bifrostReq, geminiContentToEmbeddingContent and
applyBifrostEmbeddingParams) to return an error (or at minimum log the error via
the existing logger) when geminiContentToEmbeddingContent fails, and ensure
callers handle the returned error instead of getting a nil result; apply the
same change to the analogous block at lines 400-403 so errors are not lost.
- Around line 153-155: The current nil-check lumps three failure modes into one
message; update the validation around bifrostReq (the block testing bifrostReq,
bifrostReq.Input, and len(bifrostReq.Input.Contents)) to return distinct, clear
errors for each case (e.g., "bifrost request is nil", "bifrost request input is
nil", and "bifrost request input contents is empty") so callers can tell whether
Input exists but Contents is empty; adjust the fmt.Errorf calls accordingly
where bifrostReq and bifrostReq.Input.Contents are validated.

In `@core/providers/vertex/embedding.go`:
- Around line 40-46: The loop that builds sb silently returns nil when
encountering a non-text part (checking part.Type !=
schemas.EmbeddingContentPartTypeText || part.Text == nil), which hides why
embedding failed; update this in the function that assembles content (the loop
using sb and iterating over content/part) to log a warning including the
offending part.Type (or part index) and return an explicit error or clear
failure value instead of nil so callers get a clear signal that non-text content
was rejected; use the package logger or existing request logger to emit the
warning and replace the silent return with a descriptive error return.

In `@plugins/semanticcache/test_utils.go`:
- Around line 557-559: Replace the direct address operator usage (&t) when
populating schemas.EmbeddingContent in the loop over texts with the
repo-standard pointer helper bifrost.Ptr(t); specifically update the assignment
that currently sets Text: &t to Text: bifrost.Ptr(t) and add an import for the
bifrost package if it's not already present so the test_utils.go loop that
builds contents uses bifrost.Ptr consistently.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@core/internal/llmtests/embedding_multimodal.go`:
- Around line 107-110: The skip logic uses vertexNoBatch := testConfig.Provider
== schemas.Vertex which incorrectly prevents BatchImages/BatchMultimodal tests
for all Vertex configs; change the guard to target only the single-content
Gemini embedding route (e.g., check the model or a single-content flag instead
of Provider). Update vertexNoBatch to something like: vertexNoBatch :=
testConfig.Provider == schemas.Vertex && (testConfig.Model ==
"multimodalembedding@001" || testConfig.SingleContentGemini == true), and apply
the same change at the other occurrence (around the 208-210 block) so batch
image coverage still runs for Vertex multimodal models that support per-input
batching.

In `@core/internal/llmtests/response_validation.go`:
- Around line 1324-1326: The dimension-check logic incorrectly treats Base64
embeddings as empty because it manually inspects embedding.Embedding fields;
replace those manual checks with the existing getEmbeddingVector helper (from
core/internal/llmtests/utils.go) to extract the vector and then test len(vector)
> 0 and use that length for expected_dimensions; update all occurrences where
similar manual checks are used (the current hasData/embedding dimension
branches, and the other similar blocks noted) to call
getEmbeddingVector(embedding) instead of inspecting Base64/Binary/Int8/Uint8
fields directly so Base64 is counted and Binary/Ubinary remain intentionally
skipped.

In `@core/providers/bedrock/invoke.go`:
- Around line 397-409: The embedding request builder currently only sets
req.Input.Contents for r.InputText and r.Texts, leaving req.Input nil for
image-only or mixed requests; update the code in the embedding path that creates
req.Input so it also iterates r.Images and r.Inputs and appends corresponding
schemas.EmbeddingContent entries (using the proper EmbeddingContentPartType for
images/inputs and assigning the image URL or input payload pointers) so
req.Input is always non-nil when any of r.InputText, r.Texts, r.Images, or
r.Inputs are present; modify the section that constructs contents (the block
that sets contents := make([]schemas.EmbeddingContent, ...)) to include entries
for r.Images and r.Inputs and then set req.Input =
&schemas.EmbeddingInput{Contents: contents}.

In `@core/providers/gemini/embedding.go`:
- Around line 247-254: The current usage accounting reads only
embeddings[0].Statistics.TokenCount; update the logic in embedding.go (around
where geminiResp, embeddings and bifrostResp.Usage are handled) to sum
TokenCount across all embeddings that have Statistics (e.g., iterate embeddings
and accumulate Statistics.TokenCount when non-nil), and only if no per-embedding
statistics exist (sum == 0) fall back to
geminiResp.Metadata.BillableCharacterCount; then assign that summed value to
bifrostResp.Usage.PromptTokens and bifrostResp.Usage.TotalTokens so batched
embeddings are correctly accounted for.
- Around line 383-391: The loop currently overwrites bifrostReq.Params per item
so only the last item's embedding params survive; instead compute the params for
the first item (using applyBifrostEmbeddingParams) as the baseline, then for
each subsequent request compute its params and compare to the baseline; if any
mismatch is found, return an error (reject the batch) or only set
bifrostReq.Params if all items' params are identical. Reference the
request.Requests loop, geminiContentToEmbeddingContent,
applyBifrostEmbeddingParams, and bifrostReq.Params when locating where to
implement the baseline computation, per-item comparison, and early rejection.

In `@core/providers/vertex/embedding.go`:
- Around line 136-167: The loop that builds each multimodal instance currently
overwrites earlier parts (instance.Text, instance.Image, instance.Video) instead
of aggregating; change it to concatenate text parts (e.g., join successive
schemas.EmbeddingContentPartTypeText parts into instance.Text with a separator
like "\n\n") and treat image/video parts deterministically: if you want to
reject duplicates, return an error when instance.Image or instance.Video is
already set (with a clear message referencing
VertexMultimodalImageInput/VertexMultimodalVideoInput), or implement an explicit
merge strategy (e.g., collect multiple inputs into slices) rather than assigning
over them; update the switch handling of schemas.EmbeddingContentPartTypeImage
and ...Video (including use of extractBase64FromDataURI) to check for existing
instance.Image/instance.Video before assigning, and ensure the final instances =
append(instances, instance) receives the aggregated instance.
- Around line 212-237: The current converter emits multiple EmbeddingData
entries per `prediction` (from `prediction.TextEmbedding`,
`prediction.ImageEmbedding`, and `prediction.VideoEmbeddings`), breaking the 1
content → 1 embedding contract; update the code that builds `embeddings` (the
block creating schemas.EmbeddingData from `prediction`) so it produces exactly
one EmbeddingData per `prediction`: either (A) merge modality vectors into a
single vector (e.g., concatenate or compute a fixed-size average) and set that
as the single `Embedding` for the `EmbeddingData`, or (B) pick a single modality
by priority (e.g., prefer `TextEmbedding` then `ImageEmbedding` then the first
`VideoEmbeddings` entry) and use only that vector; implement the chosen strategy
where the current multiple appends occur (refer to `prediction.TextEmbedding`,
`prediction.ImageEmbedding`, `prediction.VideoEmbeddings`, `embeddings`, and
`schemas.EmbeddingData`) and ensure `idx` is incremented exactly once per
`prediction`; alternatively, if you opt to reject mixed-modality responses,
return an explicit error upstream when more than one modality is present instead
of appending multiple rows.

In `@core/providers/vertex/vertex.go`:
- Around line 1522-1540: After converting provider responses to bifrostResponse,
guard against nil before populating ExtraFields: check if bifrostResponse == nil
after calling gemini.ToBifrostEmbeddingResponse(...) and after
vertexResponse.ToBifrostEmbeddingResponse(), and if nil return a provider error
via providerUtils.EnrichError(providerUtils.NewBifrostOperationError(...)) (use
an appropriate schemas.ErrProviderResponse* code for "no embeddings/malformed
response") passing ctx, jsonBody, responseBody, provider.sendBackRawRequest and
provider.sendBackRawResponse so you don't dereference
bifrostResponse.ExtraFields on malformed-but-200 responses.

In `@core/schemas/embedding.go`:
- Around line 66-80: The EmbeddingMediaPart.Validate currently only checks for
non-nil Data/URL and allows empty payloads; update EmbeddingMediaPart.Validate
to treat empty values as unset by verifying that Data and URL are not only
non-nil but also contain non-zero length (e.g., check len of the underlying
string/byte slice pointed to by Data and the string pointed to by URL) and only
increment set when they are non-empty; if neither is non-empty or more than one
is set, return the existing error about exactly one of data or url being set (or
a similar clear error) so blank media payloads are rejected centrally.
- Around line 29-31: The EmbeddingInput struct's Contents field lacks a JSON tag
and therefore marshals as "Contents" instead of the expected snake_case
"contents"; update the EmbeddingInput definition by adding a JSON struct tag
(e.g., `json:"contents"` or `json:"contents,omitempty"`) to the Contents field
so it serializes as "contents" consistently across the schema (reference the
EmbeddingInput type and its Contents field).

In `@framework/logstore/tables.go`:
- Line 186: The EmbeddingInputParsed field is typed as schemas.EmbeddingContent
which doesn't exist; update the type to the actual exported embedding-content
type from core/schemas and adjust the import so the file uses that package
(e.g., import core/schemas package and replace schemas.EmbeddingContent with the
exported name from core/schemas). Ensure the field declaration
EmbeddingInputParsed []<CorrectExportedType> `gorm:"-"
json:"embedding_input,omitempty"` uses the exact exported identifier and that
any references to schemas in this file are updated to the correct package alias.

In `@plugins/semanticcache/utils.go`:
- Around line 450-459: The loop that builds textParts from
req.EmbeddingRequest.Input.Contents currently returns the raw joined string,
skipping normalizeText() and causing inconsistent caching; update this path to
normalize the text the same way as getNormalizedInputForCaching() by applying
normalizeText() (either to each *part.Text before appending to textParts or to
the final strings.Join(textParts, " ")) so the returned string is the normalized
value used for hashing and embedding lookup.

In `@tests/integrations/python/tests/test_google.py`:
- Around line 25-27: The module docstring's numbered list has drifted (14 → 45 →
46 → 15); update the two inserted items titled "Multimodal embedding - text +
image content (Gemini/Vertex gemini-embedding-2-preview)" and "Multimodal
embedding - batch contents (Gemini/Vertex gemini-embedding-2-preview)" to follow
the sequence (change 45 → 15 and 46 → 16) and then adjust any subsequent list
entries (e.g., the existing "15. List models") so numbering remains monotonic
(increment following items as needed).

In `@transports/bifrost-http/handlers/inference.go`:
- Around line 1085-1089: Remove the early transport-side validation that checks
req.Input == nil || len(req.Input.Contents) == 0 and the call to
req.Input.Validate() in the inference HTTP handler; this validation is owned by
core/bifrost.go which implements the large-payload passthrough exception. Either
delete these two checks from the top of the handler or, if you must validate at
transport layer, move the checks to after the Bifrost context conversion step
and mirror the core passthrough logic (allow large/multimodal inputs through
when the Bifrost context indicates passthrough) so the handler forwards inputs
as-is and lets provider/core rejections propagate.

---

Outside diff comments:
In `@core/providers/bedrock/invoke.go`:
- Around line 1002-1019: The shim always reads d.Embedding.Float and emits a
float-only envelope (BedrockInvokeCohereEmbeddingResp with ResponseType
"embeddings_floats") even when the provider populated other types; update the
embedding response construction in the Titan/resp.Data path to inspect
EmbeddingsByType (e.g., check resp.Data[*].Embedding.EmbeddingsByType and its
Float, Int8, Uint8, Binary, Ubinary, Base64 fields) and branch accordingly to
return the matching native envelope (preserving Int8/Uint8/Binary/Ubinary/Base64
formats) or return an explicit error instead of always flattening to float;
adjust the code paths that currently reference d.Embedding.Float and
resp.Data[0].Embedding.Float to use the correct EmbeddingsByType fields and set
ResponseType to the correct native type when building
BedrockInvokeCohereEmbeddingResp or BedrockInvokeEmbeddingResp.

In `@core/providers/gemini/types.go`:
- Around line 1255-1279: The code only falls back to top-level file_data into
aux.FileDataSnake but does not translate nested snake_case fields into the
canonical FileData, so Python-style payloads like file_data: {"file_uri": "...",
"mime_type": "..."} end up as empty fields. Update the unmarshal/assignment
logic for PartAlias/FileData handling: add a FileDataSnake struct (or ensure
aux.FileDataSnake exists) that defines snake_case fields (file_uri, mime_type,
display_name), then after sonic.Unmarshal map those snake_case fields into the
canonical FileData fields (e.g., p.FileData.FileUri = aux.FileDataSnake.FileUri,
p.FileData.MimeType = aux.FileDataSnake.MimeType, p.FileData.DisplayName =
aux.FileDataSnake.DisplayName) when p.FileData is nil so nested snake_case
payloads are correctly populated; keep references to PartAlias, FileData,
FileDataSnake, p.FileData and sonic.Unmarshal to locate where to modify the
code.

In `@ui/app/workspace/logs/sheets/logDetailView.tsx`:
- Around line 947-953: The isEmbedding detection currently derives from
log.object === "list", causing real embedding logs to be missed and list-model
logs misclassified; update the isEmbedding checks (the variable named
isEmbedding and any similar checks around the copy-request-body branch that
reference log.object) to use log.object === "embedding" (and include the chunk
variant if needed, e.g., "embedding.chunk") so the copy button uses
log.embedding_input for true embedding logs; apply the same replacement at the
other occurrence near the copy-request-body logic (the block around the second
isEmbedding declaration).

---

Nitpick comments:
In `@plugins/semanticcache/test_utils.go`:
- Around line 555-562: Replace direct address-of usages when building the
EmbeddingInput contents with the repo helper: in the anonymous Input func that
returns *schemas.EmbeddingInput (the block creating contents :=
make([]schemas.EmbeddingContent, len(texts)) and assigning contents[i] =
schemas.EmbeddingContent{{Type: schemas.EmbeddingContentPartTypeText, Text:
&t}}), use bifrost.Ptr(t) instead of &t so the Text pointer is created via
bifrost.Ptr(...) for consistency with project conventions.

Verify each finding against the current code and only fix it if needed.

Outside diff comments:
In `@core/providers/bedrock/invoke.go`:
- Around line 413-452: The code currently only forwards MaxTokens and Truncate
via extraParams, but cohere.ToCohereEmbeddingRequest expects typed fields on
schemas.EmbeddingParameters; update the mapping so that if r.MaxTokens != nil
set params.MaxTokens = *r.MaxTokens and if r.Truncate != nil set params.Truncate
= *r.Truncate (in addition to keeping them in extraParams if desired) before
assigning req.Params, ensuring schemas.EmbeddingParameters carries these typed
values for downstream cohere conversion.
- Around line 999-1011: The current branch unconditionally converts embeddings
from resp.Data using d.Embedding.Float and returns a
BedrockInvokeCohereEmbeddingResp with ResponseType "embeddings_floats"; instead,
detect which embedding field is present on each resp.Data item (e.g.,
d.Embedding.Float, d.Embedding.Base64, d.Embedding.Int8, d.Embedding.Uint8,
d.Embedding.Binary, d.Embedding.Ubinary) and preserve the native typed data in
the response envelope rather than forcing float conversion—update the logic
around resp.Data iteration to build a payload that keeps the original type and
set ResponseType to "embeddings_by_type" (or the appropriate native-type tag)
when non-float embeddings are present so Bedrock clients receive the original
typed embeddings intact while still falling back to the float path for Float
embeddings; ensure you return a BedrockInvokeCohereEmbeddingResp that contains
the corresponding typed field(s) rather than always populating Embeddings from
d.Embedding.Float.

---

Duplicate comments:
In `@core/internal/llmtests/response_validation.go`:
- Around line 1345-1360: The expected-dimensions check currently inspects only
Float/Int8/Uint8/Binary/Ubinary fields and thus treats Base64 embeddings as
zero-length; update the logic that computes actualDimensions (the block inside
the if for expectations.ProviderSpecific["expected_dimensions"] and the similar
block around lines 1530-1545) to call and reuse getEmbeddingVector(...) to
derive the embedding vector length instead of the manual switch, so both
validation and recorded embedding_dimensions use the same representation; use
the returned slice length from getEmbeddingVector(response.Data[i].Embedding)
(handling any error/ok result per existing helper convention) to set
actualDimensions and keep metric/validation consistent.

---

Nitpick comments:
In `@core/providers/openai/types.go`:
- Around line 134-135: The inline comment on the Input field of the embedding
request is outdated; update the comment for Input *OpenAIEmbeddingInput in
core/providers/openai/types.go (next to the Model field) to list all supported
shapes: string, []string, []int, and [][]int (or similar phrasing) so it
accurately documents the OpenAIEmbeddingInput type's four accepted forms.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@core/providers/gemini/embedding.go`:
- Around line 190-206: The loop is incorrectly copying the aggregate
bifrostResp.Usage.PromptTokens into each GeminiEmbedding.Statistics causing
overcounting; remove the per-item assignment inside the loop in embedding.go (do
not set ContentEmbeddingStatistics within the for i, embedding := range
bifrostResp.Data block) and instead only populate geminiResp.Embeddings with
Values there; after the loop, if there is exactly one embedding
(len(geminiResp.Embeddings) == 1) set geminiResp.Embedding and then assign
Statistics on that single embedding using bifrostResp.Usage.PromptTokens (via
ContentEmbeddingStatistics) while keeping the aggregate usage in
geminiResp.Metadata as you already do; do not create per-item Statistics from
aggregate Usage when batching.

In `@core/providers/openai/embedding.go`:
- Around line 135-160: The loop over each content entry can silently drop
entries when all parts have nil/empty Text and no Tokens, causing index
mismatches; after the inner loop that builds sb and tokens (the loop iterating
over part in content and using sb, tokens, texts, tokenBatches), add a guard: if
sb.Len() == 0 && len(tokens) == 0 return an error (e.g. fmt.Errorf("openai
embedding received empty content entry: all parts have nil/empty Text and no
Tokens")) so the caller is notified instead of silently discarding the input;
this mirrors the defensive behavior in extractTextFromContent used in the
HuggingFace converter.

In `@core/providers/openai/openai.go`:
- Around line 1945-1959: The large-payload branch must use the same
OpenAI→Bifrost conversion as the normal path: instead of unmarshalling directly
into schemas.BifrostEmbeddingResponse, unmarshal into OpenaiEmbeddingResponse
and call its ToBifrostEmbeddingResponse() to produce the Bifrost response; also
populate rawRequest/rawResponse via customResponseHandler or
providerUtils.HandleProviderResponse just like the normal branch, and use
providerUtils.EnrichError for error handling to keep schema and multimodal/typed
embedding fields consistent across both paths (refer to OpenaiEmbeddingResponse,
ToBifrostEmbeddingResponse, customResponseHandler,
providerUtils.HandleProviderResponse, and providerUtils.EnrichError).

In `@core/providers/vertex/embedding.go`:
- Around line 148-149: Validate that part.Image.URL and part.Video.URL start
with "gs://” before setting img.GCSUri or vid.GCSUri: use
strings.HasPrefix(*part.Image.URL, "gs://") and
strings.HasPrefix(*part.Video.URL, "gs://") and if the check fails return an
error (e.g., fmt.Errorf("image/video URL must be a GCS URI (gs://...)")) instead
of assigning; add the necessary strings import and apply the same validation
logic to both the image assignment (img.GCSUri) and the video assignment
(vid.GCSUri) so non-gs:// URIs are rejected locally rather than sent to Vertex.

In `@core/schemas/embedding.go`:
- Around line 226-232: The EmbeddingsByType struct currently declares Binary
[]int8 and Ubinary []uint8 which breaks the public contract; change these fields
to Binary []byte and Ubinary []byte (keeping their json tags and other fields
unchanged) so the struct matches the repo-wide contract and callers/converters
expecting packed-binary embeddings continue to work; update any related comments
or docs referencing Binary/Ubinary types if present.
- Around line 117-152: The EmbeddingContentPart validator currently only checks
p.Tokens for nil, allowing an empty slice (Tokens: []int{}) to pass; update the
EmbeddingContentPartTypeTokens branch in the Validate method to reject empty
token slices by checking len(p.Tokens) == 0 and returning an error like
"embedding content part type %q requires non-empty tokens payload" when
zero-length, instead of only checking for nil.

---

Duplicate comments:
In `@core/providers/gemini/embedding.go`:
- Around line 396-407: The conversion in the Gemini->Bifrost path currently
collapses per-item params into a single Params using
applyBifrostEmbeddingParams(bifrostReq.Params, request.Requests[0]) which
silently drops differing per-request fields; update the logic in the function
handling request.Requests so that before collapsing you iterate request.Requests
and verify that taskType, title, outputDimensionality, documentOcr, and
audioTrackExtraction (the per-item fields) are identical across all entries — if
they are identical set bifrostReq.Params once from any entry, otherwise return
an error/reject the batch (or alternatively return a clear validation error) so
heterogeneous batches are not silently lost; reference
geminiContentToEmbeddingContent and BifrostEmbeddingRequest when implementing
the check.

In `@core/providers/vertex/embedding.go`:
- Around line 212-237: The code currently appends multiple embedding rows per
prediction (text, image, and every video), breaking the 1 content -> 1 output
invariant; change the logic in the embedding construction (the block that
references prediction.TextEmbedding, prediction.ImageEmbedding,
prediction.VideoEmbeddings, schemas.EmbeddingData and idx) to pick exactly one
embedding per prediction—e.g., choose prediction.TextEmbedding if present, else
prediction.ImageEmbedding, else the first entry of
prediction.VideoEmbeddings—and append a single schemas.EmbeddingData with that
chosen vector and increment idx once. Ensure you copy the chosen slice into
EmbeddingsByType{Float: append([]float64(nil), ...)} as before and remove the
multiple appends/loop.
- Around line 136-167: The loop currently overwrites
instance.Text/instance.Image/instance.Video for each part, losing earlier parts;
change it to aggregate parts: concatenate text fragments into instance.Text
(e.g., append with separator or join), and collect image and video inputs into
slices (e.g., instance.Images []VertexMultimodalImageInput and instance.Videos
[]VertexMultimodalVideoInput) instead of single pointers; update the Vertex
multimodal instance type and any downstream consumers that reference
instance.Image/instance.Video to handle slices, and in the switch cases append
the created img/vid values rather than assigning them.

---

Nitpick comments:
In `@core/providers/azure/azure.go`:
- Around line 880-883: Remove the provider-level population of
ExtraFields.Provider in the Azure embedding response path: after calling
openaiResp.ToBifrostEmbeddingResponse() you should not set
response.ExtraFields.Provider = provider.GetProviderKey(); leave other fields
(e.g., response.ExtraFields.Latency = latency.Milliseconds()) intact. The core
centralizer (*BifrostResponse).PopulateExtraFields is responsible for filling
OriginalModelRequested, Provider, and ResolvedModelUsed, so delete the
assignment of Provider here to avoid duplicating/contradicting that contract.

In `@core/providers/openai/openai.go`:
- Around line 1960-1961: Remove the premature population of provider/model
attribution in core/providers/openai/openai.go by deleting the assignments to
response.ExtraFields.Provider and response.ExtraFields.ResolvedModelUsed (and
any similar direct writes such as OriginalModelRequested) so the centralized
population path can run; locate the block where response.ExtraFields is being
set in the OpenAI handler and remove those provider/model assignments, leaving
other extra-field writes intact and relying on
(*BifrostResponse).PopulateExtraFields in core/bifrost.go to populate Provider,
OriginalModelRequested, and ResolvedModelUsed.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@core/internal/llmtests/embedding_multimodal.go`:
- Around line 106-110: The MultimodalEmbedding test sends BatchText (which
builds a single request with three EmbeddingContent entries) unguarded and will
fail for Gemini Vertex models; move the vertexNoBatch guard so BatchText is
skipped for Vertex Gemini (or derive skip from MultimodalEmbeddingModel) before
calling BatchText inside the run closure. Specifically, update the
t.Run("MultimodalEmbedding", ...) logic that defines vertexNoBatch and the run
func to check vertexNoBatch (or model-based condition using
MultimodalEmbeddingModel/ToVertexGeminiEmbeddingRequest()) and skip BatchText
the same way BatchImages and BatchMultimodal are already gated.

In `@core/providers/gemini/gemini.go`:
- Around line 1342-1343: The debug log is writing the full upstream response
body (provider.logger.Debug(fmt.Sprintf("error from %s provider: %s",
providerName, string(resp.Body())))), which may contain user content; change
this to avoid logging raw resp.Body() — replace it with a sanitized summary such
as response status, providerName, and a truncated or redacted snippet (e.g.,
first N bytes or a fixed message like "<redacted body>") before calling
providerUtils.EnrichError and parseGeminiError, keeping the calls to parsedErr
:= providerUtils.EnrichError(ctx, parseGeminiError(resp), jsonData, nil,
provider.sendBackRawRequest, provider.sendBackRawResponse) intact.

In `@core/providers/vertex/embedding.go`:
- Around line 37-46: The code in the loop over bifrostReq.Input.Contents builds
multi-part text by concatenating parts directly (strings.Builder sb +
sb.WriteString) which collapses boundaries; change the join to insert a
delimiter between parts (e.g., a single space or newline) so tokens don’t
merge—update the loop that iterates parts (the variables sb and part in
embedding.go) to check if sb.Len() > 0 and then append a delimiter
(sb.WriteByte(' ') or sb.WriteString("\n")) before sb.WriteString(*part.Text) so
single-part entries remain unchanged but adjacent parts are separated.

In `@core/schemas/embedding.go`:
- Around line 55-59: The EffectiveParams method currently returns i.Params or
defaultParams directly which overwrites defaults and can cause shared-pointer
races; change BifrostEmbeddingBatchItem.EffectiveParams to create a clone of
defaultParams, deep-copy any map fields (e.g., NetworkConfig.ExtraHeaders and
other maps using maps.Copy), then overlay non-nil/non-zero fields from i.Params
onto that clone and return the clone so per-item mutations cannot bleed across
items; apply the same clone+overlay pattern to the similar code region
referenced (the other EffectiveParams-like logic around the 233-245 area) to
ensure all map fields are copied to avoid concurrent data races.

In `@transports/bifrost-http/integrations/genai.go`:
- Around line 170-191: The non-Gemini fallback flattens bifrostBatchReq (from
geminiReq.ToBifrostBatchEmbeddingRequest) into a single EmbeddingRequest and
drops any per-item overrides; detect per-item overrides on bifrostBatchReq.Items
(e.g., item.Params, item.Fallbacks, or any fields that differ from
bifrostBatchReq.Params/Fallbacks) and handle them explicitly: either return a
clear error rejecting non-Gemini batch requests that contain per-item overrides,
or implement a fan-out that builds one schemas.BifrostRequest per item
(preserving each item.Content plus its Params/Fallbacks) instead of collapsing
to a single EmbeddingRequest; update the branch that constructs and returns
&schemas.BifrostRequest{EmbeddingRequest: ...} to perform this check and take
the chosen action.

---

Outside diff comments:
In `@plugins/logging/main.go`:
- Around line 514-551: Add a new case for schemas.BatchEmbeddingRequest
mirroring the schemas.EmbeddingRequest branch: set initialData.Params =
req.BatchEmbeddingRequest.Params, extract each item's embedding content (reuse
or call the same helper used by EmbeddingRequest, e.g., extractEmbeddingInput
but adapted for batch input), compute totalDataSize by iterating each item's
media parts and redact large media via redactEmbeddingMediaData when threshold
from ctx (schemas.BifrostContextKeyLargePayloadRequestThreshold) is exceeded,
then assign the resulting slice to initialData.EmbeddingInput so batch embedding
requests log their (possibly redacted) inputs.

---

Duplicate comments:
In `@core/providers/openai/types.go`:
- Around line 1118-1161: The PR reintroduces a deprecated legacy embedding wire
model (EmbeddingStruct with EmbeddingStr, EmbeddingArray, Embedding2DArray and
its MarshalJSON/UnmarshalJSON) which conflicts with the current embedding
contract; remove EmbeddingStruct and its custom JSON methods and instead ensure
provider responses use the single canonical wire shape ([]float64) and map into
the existing EmbeddingsByType conversion flow (see EmbeddingsByType in
core/schemas/embedding.go) in the provider converters/adapter functions so all
providers funnel through the same conversion path.

In `@core/providers/vertex/embedding.go`:
- Around line 215-240: The code currently appends one EmbeddingData per modality
(prediction.TextEmbedding, prediction.ImageEmbedding,
prediction.VideoEmbeddings) which violates the 1-content→1-embedding contract;
change the logic in the loop that builds embeddings so each prediction yields
exactly one schemas.EmbeddingData (keep using the embeddings slice,
schemas.EmbeddingData and idx), e.g. if prediction.TextEmbedding is non-empty
choose that as the single embedding, else if prediction.ImageEmbedding is
non-empty choose that, else if prediction.VideoEmbeddings has elements choose
the first VideoEmbedding; construct one EmbeddingData with the selected vector
(using append([]float64(nil), ...)) and increment idx once, or alternatively
return an error when multiple modality vectors are present if you prefer to
reject multimodal responses.
- Around line 134-166: The loop over bifrostReq.Input.Contents currently
overwrites earlier parts in a single VertexEmbeddingInstance; fix by
concatenating repeated text parts and explicitly handling duplicate image/video
parts: when processing part.Type in the loop for each content, if part.Type is
EmbeddingContentPartTypeText append part.Text to instance.Text (with a space or
newline) instead of assigning, and for EmbeddingContentPartTypeImage /
EmbeddingContentPartTypeVideo check if instance.Image or instance.Video is
already set and either (a) return a clear error rejecting multiple image/video
parts in one EmbeddingContent or (b) change VertexEmbeddingInstance to accept
slices (e.g., Images []VertexMultimodalImageInput, Videos
[]VertexMultimodalVideoInput) and append new entries; apply the same payload
validation (Data vs URL and gs:// checks) before appending, and ensure
downstream request building uses the new concatenated/merged fields.

In `@tests/integrations/python/tests/test_cohere.py`:
- Around line 158-196: Both tests run against all embedding providers but rely
on Cohere-only features (output_dimension=512 and int8 embeddings); add
capability guards so they skip when the provider/model doesn't support those
features. In test_06_custom_dimensions_embedding and
test_07_multiple_embedding_types, call or implement capability checks before
getting the client (e.g., a helper like supports_output_dimension(provider,
model) and supports_embedding_type(provider, model, "int8") or reuse existing
provider capability helpers) and call pytest.skip when unsupported; keep the
rest of each test (client = get_provider_cohere_client(...), response =
client.embed(...), and assertions) unchanged and reference the existing symbols
test_06_custom_dimensions_embedding, test_07_multiple_embedding_types,
get_provider_cohere_client, format_provider_model to locate where to insert the
guard.

---

Nitpick comments:
In `@core/providers/bedrock/embedding.go`:
- Around line 101-106: The current nil-check on
cohere.ToCohereEmbeddingRequest(bifrostReq) hides specific conversion errors;
change the converter signature from func
ToCohereEmbeddingRequest(*schemas.BifrostEmbeddingRequest)
*CohereEmbeddingRequest to func
ToCohereEmbeddingRequest(*schemas.BifrostEmbeddingRequest)
(*CohereEmbeddingRequest, error), update all call sites, and here (in
embedding.go) capture the returned (cohereReq, err), return nil, err when err !=
nil instead of the generic fmt.Errorf message so specific failure reasons
propagate; update references to cohereReq and any related tests accordingly.

In `@core/providers/cohere/embedding_test.go`:
- Around line 97-99: Add assertions that validate the actual payload values for
the mapped content blocks in addition to their types: after the existing
assertions on CohereContentBlockTypeText and CohereContentBlockTypeImage, assert
that req.Inputs[0].Content[0] contains the original text payload (e.g., the text
field/value equals the text string used earlier in the test) and that
req.Inputs[0].Content[1] contains the original image payload (e.g., the image
URL or image field/value equals the image string used earlier in the test) so
regressions in mapping are caught.

In `@core/providers/gemini/gemini.go`:
- Around line 1290-1393: BatchEmbedding duplicates the full request/response
lifecycle from Embedding; extract the common setup, send, large-response
handling, and response parsing into a shared helper to avoid drift. Create a
helper on GeminiProvider (e.g., executeEmbeddingRequest or handleEmbeddingFlow)
that accepts the prepared jsonData, endpoint path
("/models/<model>:embedContents" vs ":batchEmbedContents"), expected response
target type (single vs batch struct), model name, and flags for raw
request/response sending; move code that sets headers, applies large payload
logic (ApplyLargePayloadRequestBody/DrainLargePayloadRemainder), makes the
request (PrepareResponseStreaming/MakeRequestWithContext), finalizes response
(FinalizeResponseWithLargeDetection), parses via HandleProviderResponse, and
builds the BifrostEmbeddingResponse/ExtraFields into that helper; then call this
helper from BatchEmbedding and Embedding, keeping model-specific conversion
functions (ToGeminiBatchEmbeddingRequest, ToGeminiEmbeddingRequest,
ToBifrostEmbeddingResponse) in the callers.

In `@plugins/semanticcache/test_utils.go`:
- Around line 553-556: Replace the use of the address operator when constructing
EmbeddingContent parts with the repository helper; instead of using Text: &t in
the loop that builds contents (the schemas.EmbeddingContent literal with Type:
schemas.EmbeddingContentPartTypeText), call bifrost.Ptr(t) to create the pointer
consistently, and add the bifrost import if missing.